package com.eedi.framework.user.dal.mapper;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjUtil;
import cn.hutool.core.util.StrUtil;
import com.eedi.framework.user.controller.org.vo.*;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.eedi.framework.common.enums.CertTypeEnum;
import com.eedi.framework.common.enums.CommonStatusEnum;
import com.eedi.framework.common.enums.UserTypeEnum;
import com.eedi.framework.common.pojo.PageResult;
import com.eedi.framework.common.util.object.BeanUtils;
import com.eedi.framework.mybatis.core.mapper.BaseMapperX;
import com.eedi.framework.mybatis.core.query.LambdaQueryWrapperX;
import com.eedi.framework.mybatis.core.query.MPJLambdaWrapperX;
import com.eedi.framework.permission.dal.dataobject.OrgRoleDO;
import com.eedi.framework.permission.dal.dataobject.OrgUserRoleDO;
import com.eedi.framework.permission.enums.OrgRoleCodeEnum;
import com.eedi.framework.user.controller.org.vo.*;
import com.eedi.framework.user.convert.OrgUserConvert;
import com.eedi.framework.user.dal.dataobject.OrgUserDO;
import org.apache.ibatis.annotations.Mapper;

import java.time.LocalDateTime;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.Set;

@Mapper
public interface OrgUserMapper extends BaseMapperX<OrgUserDO> {


    default String getPwdByLoginId(String orgUserLoginId) {
        return selectOne(OrgUserDO::getOrgUserLoginId, orgUserLoginId).getOrgUserPassword();
    }

    default OrgUserLoginInfoResp create(OrgUserAccountCreateReq req, CommonStatusEnum orgUserAccountStatus) {
        OrgUserDO item = BeanUtils.toBean(req, OrgUserDO.class);
        item.setOrgUserAccountStatus(orgUserAccountStatus);
        item.setOrgUserAccountType(UserTypeEnum.MEMBER_OPS);
        item.setOrgUserLoginId(req.getOrgUserLoginId());
        //兜底，如果上层传递了证件号，而没有传递证件类型，那么默认认为是身份证号
        if (ObjUtil.isNull(item.getOrgUserCertType()) && ObjUtil.isNotNull(item.getOrgUserCertNo())) {
            item.setOrgUserCertType(CertTypeEnum.ID_CARD);
        }
        insert(item);
        return BeanUtils.toBean(item, OrgUserLoginInfoResp.class);
    }

    default void updateStatusByOrgUserAccountId(String orgUserId, CommonStatusEnum orgUserAccountStatus) {
        OrgUserDO item = new OrgUserDO();
        item.setOrgUserId(orgUserId);
        item.setOrgUserAccountStatus(orgUserAccountStatus);
        updateById(item);
    }


    default PageResult<OrgUserLoginInfoResp> page(OrgUserAccountPageReq req) {
//        PageResult<OrgUserDO> orgUserAccountDOPageResult = selectPage(req, new LambdaQueryWrapperX<OrgUserDO>()
//                .likeIfPresent(OrgUserDO::getOrgUserMobile, req.getOrgUserMobile())
//                .likeIfPresent(OrgUserDO::getOrgUserName, req.getOrgUserName())
//                .likeIfPresent(OrgUserDO::getOrgUserLoginId, req.getOrgUserLoginId())
//                .eqIfPresent(OrgUserDO::getOrgUserAccountStatus, req.getOrgUserAccountStatus())
//                .orderByDesc(OrgUserDO::getId));
//        return orgUserAccountDOPageResult.convertPage(OrgUserConvert.INSTANCE::convert);

        MPJLambdaWrapper<OrgUserDO> lambdaWrapper = new MPJLambdaWrapperX<OrgUserDO>()
                .selectAll(OrgUserDO.class)
                .leftJoin(OrgUserRoleDO.class,OrgUserRoleDO::getOrgUserId,OrgUserDO::getOrgUserId)
                .leftJoin(OrgRoleDO.class,OrgRoleDO::getOrgRoleId,OrgUserRoleDO::getOrgRoleId)
                .ne(OrgRoleDO::getOrgRoleCode, OrgRoleCodeEnum.ORG_ADMIN)
                .orderByDesc(OrgUserDO::getId);
        if (Objects.nonNull(req.getOrgUserMobile())) {
            lambdaWrapper.likeRight(OrgUserDO::getOrgUserMobile, req.getOrgUserMobile());
        }
        if (Objects.nonNull(req.getOrgUserName())) {
            lambdaWrapper.likeRight(OrgUserDO::getOrgUserName, req.getOrgUserName());
        }
        if (Objects.nonNull(req.getOrgUserLoginId())) {
            lambdaWrapper.likeRight(OrgUserDO::getOrgUserLoginId, req.getOrgUserLoginId());
        }
        if (Objects.nonNull(req.getOrgUserAccountStatus())) {
            lambdaWrapper.eq(OrgUserDO::getOrgUserAccountStatus, req.getOrgUserAccountStatus());
        }
        return selectJoinPage(req,OrgUserLoginInfoResp.class,lambdaWrapper);
    }



    default PageResult<OrgUserLoginInfoResp> page(OrgUserAccountPageReq req, Collection<String> orgUserIds) {
        PageResult<OrgUserDO> orgUserAccountDOPageResult = selectPage(req, new LambdaQueryWrapperX<OrgUserDO>()
                .inIfPresent(OrgUserDO::getOrgUserId, orgUserIds)
                .likeIfPresent(OrgUserDO::getOrgUserMobile, req.getOrgUserMobile())
                .likeIfPresent(OrgUserDO::getOrgUserName, req.getOrgUserName())
                .orderByDesc(OrgUserDO::getId));
        return orgUserAccountDOPageResult.convertPage(OrgUserConvert.INSTANCE::convert);
    }

    default void resetPassword(String orgUserId, String password) {
        OrgUserDO item = new OrgUserDO();
        item.setOrgUserId(orgUserId);
        item.setOrgUserPassword(password);
        updateById(item);
    }

    default void resetMobile(String orguserId, String orgUserAccountMobile) {
        OrgUserDO item = new OrgUserDO();
        item.setOrgUserId(orguserId);
        item.setOrgUserMobile(orgUserAccountMobile);
        //仅支持手机号登录
        item.setOrgUserLoginId(orgUserAccountMobile);
        updateById(item);
    }


    default OrgUserLoginInfoResp selectByLoginId(String orgUserAccountLoginId) {
        LambdaQueryWrapperX<OrgUserDO> queryWrapper = new LambdaQueryWrapperX<>();
        queryWrapper.eq(OrgUserDO::getOrgUserLoginId, orgUserAccountLoginId)
                .eq(OrgUserDO::getOrgUserAccountStatus, CommonStatusEnum.ENABLE);
        return OrgUserConvert.INSTANCE.convert(selectOne(queryWrapper));

    }

    default List<OrgUserLoginInfoResp> selectByLoginIds(Set<String> orgUserAccountLoginIds) {
        LambdaQueryWrapperX<OrgUserDO> queryWrapper = new LambdaQueryWrapperX<>();
        queryWrapper.inIfPresent(OrgUserDO::getOrgUserLoginId, orgUserAccountLoginIds)
                .eq(OrgUserDO::getOrgUserAccountStatus, CommonStatusEnum.ENABLE);
        return OrgUserConvert.INSTANCE.convert(selectList(queryWrapper));

    }

    /**
     * 根据loginId或mobile查询账号
     *
     * @param loginIdList
     * @param mobileList
     * @return
     */
    default List<OrgUserLoginInfoResp> selectByLoginIdOrMobile(List<String> loginIdList, List<String> mobileList) {
        LambdaQueryWrapperX<OrgUserDO> queryWrapperX = new LambdaQueryWrapperX<>();
        queryWrapperX.in(OrgUserDO::getOrgUserLoginId, loginIdList)
                .or()
                .in(OrgUserDO::getOrgUserMobile, mobileList);
        return OrgUserConvert.INSTANCE.convert(selectList(queryWrapperX));
    }

    default OrgUserLoginInfoResp selectByMobileAndRole(String orgUserAccountMobile, UserTypeEnum userTypeEnum) {
        LambdaQueryWrapperX<OrgUserDO> queryWrapper = new LambdaQueryWrapperX<>();
        queryWrapper.eq(OrgUserDO::getOrgUserMobile, orgUserAccountMobile)
                .eq(OrgUserDO::getOrgUserAccountType, userTypeEnum)
                .eq(OrgUserDO::getOrgUserAccountStatus, CommonStatusEnum.ENABLE)
                .orderByDesc(OrgUserDO::getId);
        return OrgUserConvert.INSTANCE.convert(selectOne(queryWrapper));
    }

    default OrgUserLoginInfoResp selectByOrgUserId(String orgUserId) {
        LambdaQueryWrapperX<OrgUserDO> queryWrapper = new LambdaQueryWrapperX<>();
        queryWrapper.eq(OrgUserDO::getOrgUserId, orgUserId)
                .eq(OrgUserDO::getOrgUserAccountStatus, CommonStatusEnum.ENABLE)
                .last("limit 1");
        return OrgUserConvert.INSTANCE.convert(selectOne(queryWrapper));
    }

    default List<OrgUserLoginInfoResp> selectByOrgUserIds(Collection<String> orgUserIds) {
        if (CollUtil.isEmpty(orgUserIds)) {
            return List.of();
        }
        LambdaQueryWrapperX<OrgUserDO> queryWrapper = new LambdaQueryWrapperX<>();
        queryWrapper.in(OrgUserDO::getOrgUserId, orgUserIds);
        return OrgUserConvert.INSTANCE.convert(selectList(queryWrapper));
    }

    default OrgUserLoginInfoResp selectByAccountIdIgnoreStatus(String orgUserId) {
        LambdaQueryWrapperX<OrgUserDO> queryWrapper = new LambdaQueryWrapperX<>();
        queryWrapper.eq(OrgUserDO::getOrgUserId, orgUserId);
        return OrgUserConvert.INSTANCE.convert(selectOne(queryWrapper));
    }

    default List<OrgUserDO> selectListByNicknameLike(String orgUserName, String orgUserId) {
        return selectList(new LambdaQueryWrapperX<OrgUserDO>()
                .eqIfPresent(OrgUserDO::getOrgUserId, orgUserId)
                .eq(OrgUserDO::getOrgUserAccountStatus, CommonStatusEnum.ENABLE)
                .likeRight(OrgUserDO::getOrgUserName, orgUserName)
                .or()
                .likeRight(OrgUserDO::getOrgUserLoginId, orgUserName)
        );
    }

    default void updateLoginTime(String sysUserId, String clientId) {
        OrgUserDO user = new OrgUserDO();
        user.setOrgUserId(sysUserId)
                .setOrgUserAccountLoginIp(clientId)
                .setOrgUserAccountLoginDate(LocalDateTime.now());
        updateById(user);
    }

    default void editUserInfo(String sysUserId, OrgUserProfileEditReq req) {
        if (StrUtil.isEmpty(sysUserId)) {
            return;
        }
        OrgUserDO convert = OrgUserConvert.INSTANCE.convert(req);
        convert.setOrgUserId(sysUserId);
        updateById(convert);
    }

    default void updateOrgUserInfo(OrgUserUpReq req) {
        if (StrUtil.isEmpty(req.getOrgUserId())) {
            return;
        }
        OrgUserDO user = new OrgUserDO();
        user.setOrgUserId(req.getOrgUserId());
        if (StrUtil.isNotBlank(req.getOrgUserName())) {
            user.setOrgUserName(req.getOrgUserName());
        }
        if (ObjUtil.isNotNull(req.getOrgDeptId())) {
            user.setOrgDeptId(req.getOrgDeptId());
        }
        if (ObjUtil.isNotNull(req.getOrgUserMobile())) {
            user.setOrgUserMobile(req.getOrgUserMobile());
        }
        if (ObjUtil.isNotNull(req.getOrgUserCertNo())) {
            user.setOrgUserCertNo(req.getOrgUserCertNo());
        }
        if (ObjUtil.isNotNull(req.getOrgUserAccountStatus())) {
            user.setOrgUserAccountStatus(req.getOrgUserAccountStatus());
        }
        updateById(user);
    }

    default void batchUpdateDept(Collection<OrgUserUpReq> list) {
        for (OrgUserUpReq rowReq : list) {
            updateOrgUserInfo(rowReq);
        }

    }

    default List<OrgUserSimpleResp> findUserSimple(String orgUserNameKey, String orgUserId) {
        if (StrUtil.isBlank(orgUserNameKey) && StrUtil.isBlank(orgUserId)) {
            return List.of();
        }
        List<OrgUserDO> orgUsers = selectListByNicknameLike(orgUserNameKey, orgUserId);
        return OrgUserConvert.INSTANCE.convert2SimpleResp(orgUsers);
    }
}
